COMMENT ⊗   VALID 00014 PAGES 
RECORD PAGE   DESCRIPTION
 00001 00001
 00005 00002	\\M1NGB25\F1\.
 00008 00003	DO <function> | DO <program> | DO
 00015 00004	PARK
 00019 00005	OPEN <dist>
 00021 00006	FREE <n> <f1> ... <fn>
 00024 00007	CONO <arrive> <depart> <k> <ts> <tm> <weight>
 00027 00008	SAVE <id>
 00029 00009	JUMP <label>
 00033 00010	LINK <n>
 00034 00011	DEFINE <macro name> <par>
 00037 00012	\JThis is a programming example. We have the situation of the hand holding
 00042 00013	ERRORS
 00044 00014	RUNNING THE ARM
 00048 ENDMK
⊗;
\\M1NGB25;\F1\.
GENERAL
\JThe arm has six degrees of freedom corresponding to 6 joints. The joints
are numbered from 1 to 6 starting at the shoulder and moving out to the hand.
All rotary joint angles are measured in degrees. Joint 3 which is linear
is measured in inches.

The coordinate system is referenced to the table top with the table lying in
the x y plane at z=0 with the z axis pointing vertically up.
The origin is at the corner of the table. The base of the arm is at 20,10 approximately.

The Arm is normally controlled by specifying what happens to the hand. The program
checks that the hand will not intersect the table.

On the finger tips are two touch sensors which can interrupt arm operation.\.

The program which runs the arm is in the form of an interpreter and works in two
basic modes: Planning and Execution.
In the planning mode arm functions are assembled into a data file which may then
be executed by a "DO" command. Functions may be immediately executed by prefixing
the function call by "DO". For example.\.

	OPEN 3
	PARK
	DO

\Jwill cause a data file to be constructed, either on the 3330 as a file WAVE.TRJ or on
the Swapping disk, containing the two functions open the hand to 3 inches and then
move to the park position. These two commands are then executed by the DO.\.

	DO OPEN 3
	DO PARK

\JThis will have the same effect except that the planning program will be activated
between each function call, which is very time consumming.

It is possible to write symbolic programs either in the form of macros using the
"DEFINE" pseudo op, or by creating a text file and reading it in by a "REQUIRE"
pseudo op.

What follows is a list of the Functions, Errors and how to run the arm.\.


DO <function> | DO <program> | DO
\JIf DO is followed by a function then that function will be executed.
This does not change the state of any program being compiled.
Otherwise the <id> following the DO is taken as the program name.
If DO is terminated by a C/R then the default program is executed.
If this does not exist the servo will return an error status 3.
The default program name is that last set by FILE this is changed by DOing another program,
in which case its program name becomes the default, or by a BEGIN pseudo op.\.

REQUIRE <file spec>
\JThis causes the input scanner to read from the designated file. When an EOF is
encountered scan returns to the TTY.
<file spec>::= <file name>.<ext>[pppn]
where if <ext> is null then HAL is used and if [pppn] is missing the running pppn is
assumed.\.

DUMP <file spec>
\JThis causes a file to be opened and all transforms, vectors and macros are written 
out in symbolic form. It is the opposite to REQUIRE.
If a file already exists, of the same name, it is over-written!!!\.

TRANS <id>
<X> <Y> <Z> <O> <A> <T>
\JThis pseudo op is on two lines and is used to set up a 4x4 transformation and to
identify it with an <id>. The <X> <Y> and <Z> specify the position of a point
centrally located between the finger tips in table coordinates. <O> <A> and <T>
specify the orientation of the hand. with all three angles (in degrees) zero the
hand points in the  negative "y" direction with the fingers in a horizontal plane.
the orientation vector which points from one finger tip to the other is aligned
along the "x" axis. <O> specifies a rotation of the orientation vector about a
vertical direction; thus at <O>=90 degrees the hand still horizontal would point
along the positive "x" direction. <A> is a rotation about the orientation vector.
With <A>=90 degrees the hand always points straight down. <T> is a final rotation
about the axis of the wrist and corresponds to a rotation of the final joint.
When talking to the interpreter directly from the TTY only as many parameters that
have changed need to be retyped. Further a delimiter (which includes a space)
indicates that the parameter is to remain unchanged. For example to change the
<Z> parameter only one types\.
TRANS <id>
<space><space><Z>C/R.

VECT <id>
<X> <Y> <Z>
This is similar to TRANS except that it sets up vectors.

BEGIN <id>
\JThis pseudo op starts a program of name <id>. If this pseudo op is not given
before any instruction then a default BEGIN <default name> is automatically
generated.\.

END
\JThis closes files and deletes any save and restore cell assignments, if a program
has not been ENDed before a DO <program> is executed an automatic END is performed
but in this case the save and restore cell assignments are not lost.\.

WAIT
\JCauses the arm to stop at the corresponding point during execution. Execution may
be resumed (after executing any number of functions) by a proceed command.\.

P <integer>
\Jthis causes the arm to proceed from a wait or an error state, if the argument is
non zero execution proceeds with the last or current instruction, otherwise from
the next instruction.\.

FILE <id>
This changes the default file name to <id>. It is initially set at WAVE.

WHERE
\JThis causes the arm's position to be read and the position to be typed out.
This function is automatically executed when the program is started. It should only
be executed if the arm has been moved manually.\.

HERE <id>
\JThis is like TRANS except that the hands position is read as in WHERE to give
the initial position for the transform <id>. Its main use is in defining positions
by moving the hand and then creating a transform to represent the present position.\.

PARK
\JGenerates a trajectory to the PARK position, which has joint angles
-180, -90, 14, -90, 90, 0\.

GO <trans> | GO <trans> <dx> <fac> <axis> <deg>
\JGenerates a three part trajectory to either <trans> or in the second case
to <trans> rotated about a vector <axis>, <deg> degrees and translated an
additional vector <dx> scaled by <fac>.
There are three predeclared vectors about which the hand may be rotated:
TWIST the axis of the hand, TURN normal to the plane of the fingers and
TILT the axis through the fingers.
In the case of the translation vector there are similarly three predeclared
vectors: REACH in the direction of the fingers, SWEEP in the direction from
finger tip to finger tip and
LIFT in the direction of the normal to the plane of the fingers.
These predeclared vectors, all of magnitude 1, are in the hand coordinate
system not in the table coordinate system which makes them useful for relative motion.\.

MOVE <trans> | MOVE <trans> <dx> <fac> <axis> <deg>
\JThis is the same as GO except that a smooth trajectory is fitted through the
three positions.\.

DRAW <pos> <rot> <angle> <crank> <axis> <deg> <time> <loop>
\JThis is a controlled motion of the hand. The hand is moved to its present position
plus the vector <pos>. As it moves the hand is rotated about a vector <rot>, <angle>
degrees. If <crank> is not null then the hand is assumed to be attached to a crank
which is the initial position + <crank> and as the first motion is executed the
hand attached to the end of the crank is rotated about an axis <axis> <deg> degrees.
If loop is non zero and the initial and final positions are the same the loop motion
may be repeated continuously <loop> times. The entire motion takes <time> jiffies.
A jiffy is 1/60 th. second.\.

CHANGE <dx> <fac> <rot> <deg> <time>
\JThis causes a differential motion of vector <dx> scaled by <fac> and simultaneously
the hand rotated about a vector <rot>, <deg> degrees. The motion shall take no less
than <time> jiffies.\.

DRIVE <joint> <dist> <time>
\JThis causes joint <joint>(1 is the root joint -- 6 is the hand) to be driven <dist>
degrees, or in the case of joint 3 ---inches, in a minimum time <time>. All other joints
brakes remain on unless free joints are also specified.\.

PLACE
This causes the hand to move down until it meets some resistance.
OPEN <dist>
\JThis causes the hand to be opened or closed until the opening between the fingers
is <dist>, it gives up after about 4 seconds and returns error 22 if it is unable to
comply.\.

CLOSE <dist>
\JThis always closes the hand until it meets some resistance. It then checks that
the opening of the hand is greater than <dist>. If it is less it returns error 2.
This is useful in checking that the hand is holding something.\.

CENTER <dist>
\JThis is the same as CLOSE except that the hand is driven to close centrally over
the object using touch.\.

SCREW <vel>
\JThis instruction will drive the tool at velocity <vel> (maximum =63). It must
be MERGEd with some arm motion.\.
i.e.
	SCREW 27
	MERGE
	CHANGE REACH 1 NIL 0 100
\JWhile the hand reaches one inch the tool will drive at velocity 27. Normally
FREE joints would also be specified together with some STOPping constraint.
Note NIL, of zero value, is the only other predeclared vector.\.

FREE <n> <f1> ... <fn>
\JFor each of the <n> direction vectors <fn> joints of the arm are freed
during the next arm motion.
These joints have gravity compensation, additional forces and acceleration
compensation but no position sensitive feedback.
The vectors <fn> specify directions in table coordinates.\.

For example.

	VECT X
	1 0 0
	VECT Y
	0 1 0
	FREE 2 X Y
	CHANGE REACH 1 NIL 0 100

Would provide for free motion in the x and y direction while the hand reaches 1 inch
for the next 100 jiffies.

SPIN <n> <f1> ... <fn>
\JFor each of the <n> axis vectors <fn> joints of the arm are freed as in FREE.\.

FORCE <fv> <mv>
\JDuring the next arm motion additional predicted joint torques will be applied
such as to exert a force <fv> and moment <mv> at the hand.\.

For example.

	VECT Z
	0 0 -1
	FREE 1 Z
	VECT F
	0 0 -50
	FORCE F NIL
	CHANGE NIL 0 NIL 0 100

This would provide for a direction of free motion in the z direction while exerting
a force of 50 oz. straight down. i.e. the hand will push down at 50 oz foe the next
100 jiffies.

STOP <fv> <mv>
\JIf during the next arm motion the force and moment at the hand exceed <fv> and <mv>
the arm will stop. If such a condition is not meet during the motion an error 23
will be returned.\.

WOBBLE <deg>
\JThis causes the outer three joints to be modulated with a sine wave of amplitude
<deg> degrees.\.

NNUL
\JAt the end of the next motion do not wait to null out joint errors but stop
the arm immediately.\.




CONO <arrive> <depart> <k> <ts> <tm> <weight>
\JThis function executed immediately before any motion instruction is used to modify
the performance of that motion. All motions start at an initial position
move to a position given by initial + <depart> where <depart> is a vector which
is always restored to 0,0,3 after each motion instruction. The arm then moves
to a position given by final + <arrive> where arrive is similar to <depart>, and
then to the final position. In the case of PARK <arrive> is set to null. 
A vector <k> is used to specify the radii of gyration of the object held in the hand.
the x axis is along the direction normal to the plane of the fingers. the y direction
is along the direction of the orientation vector (between the finger tips). and the
z direction is along the fingers. The weight of the object is given in <weight> in
ounces. <ts> is the minimum time in jiffies (1/60 second) for the initial and final
parts of the trajectory, and <tm> is the minimum time for the mid part. non zero times are used to
slow down arm motions.\.

MERGE
\JThis function if executed before a motion instruction causes the instruction
before the motion instruction to be executed with the motion. This is only
useful with OPEN if it is desired to open the hand as it moves off.\.
i.e
	OPEN 3
	MERGE
	MOVE T
will cause the hand to start opening as the arm starts to move.

TOUCH <mask>
\JThis causes the arm to stop during the next instruction if any of the masked touch
sensors in <mask> are activated.\.
i.e.
	TOUCH 3
	OPEN 0
\Jwill cause the hand to close until it touches something.
If it touches anything an error <mask>&6 is returned where <mask> are those sensors
which have been activated.\.

SAVE <id>
\JThe current deviation in x,y and z from the set point is saved in cell <id>.
for example if the hand were move to a position T and then CENTERed the 
deviation of position of the hand from T, after the centering operation can be saved in <id>\.
i.e.
	MOVE T
	CENTER 1
	SAVE C1
Note that this does not save any change in hand orientation.

SET <id> <vect>
\JThis will preload cell <id> with the deviation x,y,z in vector <vect>.\.

RESTORE <id> <int>
\JThis instruction must be executed immediately after a MOVE or GO instruction
and will cause the hand to move to the position specified plus the deviation.
SAVEd in cell <id>. If <int> is non zero the cell will be freed for further use.\.
i.e.
	MOVE T
	RESTORE C1 1
\Jwill cause the hand to move to T plus the vector SAVEd in C1.
It will also free up C1 for further use.\.

JUMP <label>
\JAll instructions may be labelled by a label followed by a colon, and the JUMP
instruction will cause control to jump to that instruction.\.
i.e.
L1:	MOVE T
	PARK
	JUMP L1
will cause an infinite loop.

SKIPE <error>
\JIf error <error> occurs during execution on the previous instruction then
the following instruction is skipped.\.
i.e.
L1:	OPEN 3
	CHANGE REACH 1 NIL 0 0
	CLOSE 1
	SKIPE 2
	JUMP L2
	JUMP L1
L2:
will cause the hand to advance by inches snapping its jaws until it finds something
wider than 1 inch.

SKIPN <error>
\JThe same as SKIPE except that it skips only if the error did not occur. Which makes
the last example cleaner.\.
L1:	OPEN 3
	CHANGE REACH 1 NIL 0 0
	CLOSE 1
	SKIPN 2
	JUMP L1

SKIPS <error>
\JThis is like SKIPE in that the right octal digit of the error must match exactly
but it also requires that the logical AND of the high order digits with <error>
is true. This is mostly used in touch work. For example if either error 46 or 
error 16 would indicate some state then a SKIPS 56 would detect it.\.

AOJ <label>
\JThis is the same as JUMP except that it will perform a spiral box search as follows.
A SEARCH command must have first been executed to calculate the differential joint
angle changes to make an x deviation and a y deviation at the place that the search
must be executed. Then every time the AOJ instruction is executed it first performs
a RESTORE of appropriate magnitude to generate the spiral and then performs the JUMP.\.
i.e.
	MOVE T
	SEARCH 1
L1:	MOVE T
	AOJ L1
\JWill cause a spiral search in one inch steps. The first move to T is important
as the context for the SEARCH must be established.\.

SEARCH <step>
\JComputes the change in joint angles to conduct a search, in the x,y plane, where the arm is currently
planned to be and zeros the AOJ counters.\.

FLUSH
\JDue to the partial paging scheme used by the arm, Jumps must occur within pages
This instruction will cause a new page to be started. This will soon go away.\.

LINK <n>
\JWill cause the transformation of link  <n> ( 3 ≤ n ≤6) to be typed out.\.

GRASP
Causes the current hand opening to be typed out.

WEIGHT
\JCauses the uncompensated weight that the hand is believed to be holding,
based on error torques, to be typed out.\.

I
Causes the joint angles to be typed out.
DEFINE <macro name> <par>
<body>
\JThis defines a macro of name <macro name> and formal parameters given by <par>
a list of identifiers.
The body then follows,line by line.
The macro is terminated by a blank line.
macros may be nested. An example\.
DEFINE GRAB MIN
MOVE T
CLOSE MIN

If the macro call appears then the expanded code will be assembled.
	GRAB 2
will assemble as
	MOVE T
	CLOSE 2
\JThese macros are written out by the DUMP command and are read in by the REQUIRE command.\.

ED <macro name>
\JThis is a rudementary editor.
The <macro name> must be given the first time but need not be gived again if the same
macro is to be re-edited.
The macro definition is then presented line by line every time a C/R is typed.
Previous lines may be retrieved by typing ALT.\.
	A "D" will delete the current line
	An "I" will insert a line after the present line, to be typed in.
	An "R" will replace the current line with one to be typed in.
	A "T" will cause the next line to be typed.
\JAll these commands may be preceded by an unsigned integer which will do n of them.
For example 5D will delete the current and next 4 lines.
When you have finished editing the macro type "E" then the macro
will be read in again and redefined. (assuming that the first line which
has the DEFINE is not deleted. This by the way is a good way to modify existing
macros if the macro name is changed  a new macro will be defined.
One additional feature is
"F" followed SOS manner by a string. It will then do a series of C/Rs until
a line with a matching string is found.\.
\JThis is a programming example. We have the situation of the hand holding
the screw driver which has a screw on its end. We want to insert the screw
into a hole and to screw it all the way in.\.
\←R\-L\/'2;\+L\→M\.
	DEFINE	SCRW	H A		\←M\→.;The macro to screw the screw into hole H using
					\←M\→.;approach A
	VECT SA				\←M\→.;The departure vector from the screw dispenser
	0 -1 2
	VECT SCK			\←M\→.;The radii of gyration of the screw driver
	.5 1.0 1.0
	CONO A SA SCK 10 40 50		\←M\→.;Set up the conditions for the move
	FIND H H 1			\←M\→.;A nested macro call to perform the search
	VECT FV				\←M\→.;The force to verify that it is in the hole
	0 0 -60
	STOP FV NIL			\←M\→.;Stop during the next motion
	CHANGE REACH .7 NIL 0 0		\←M\→.;If the arm goes .7 inch then we are not
					\←M\→.;in the hole and the arm will stop with
					\←M\→.;error 23
	FREE 3 X Y Z			\←M\→.;X, Y and Z are vectors in the x, y and z
					\←M\→.;directions. This will specify three degrees
					\←M\→.;of freedom.
	VECT FV				\←M\→.;We will wnat to push down with this force
	0 0 -60
	FORCE FV NIL			\←M\→.;Push with force FV
	VECT MV				\←M\→.;This is the stopping moment
	0 0 -100
	STOP NIL MV			\←M\→.;Stop when we meet it.
	SCREW 60			\←M\→.;Drive the screw driver at this velocity
	MERGE				\←M\→.;while
	CHANGE NIL 0 NIL 0 100		\←M\→.;we go nowhere while pushing down, with three
					\←M\→.;free joints, monitoring the torque.
L1:	FREE 2 X Y			\←M\→.;The screw is now in and we must pull the
					\←M\→.;screw driver out. We want two degrees of fredom.
	WOBBLE .2			\←M\→.;Shake things around a bit
	CHANGE REACH -.2 NIL 0 0	\←M\→.;while we go up 0.2 inches
	VECT FV				\←M\→.;Set up a force
	0 0 100
	STOP FV NIL			\←M\→.;and stop if it is exceeded during the next
					\←M\→.;motion, indicating that the driver is jammed
					\←M\→.;in the screw.
	NNUL				\←M\→.;dont null errors
	CHANGE Z 1 NIL 0 50		\←M\→.;and try to go up an inch.
	SKIPE 23			\←M\→.;this means that the stopping force of 100 oz
					\←M\→.;was not meet and all is O.K.
	JUMP L1				\←M\→.;if not try again
	CONO SA A SCK 10 0 0		\←M\→.;Set up the return conditions
	GO SC				\←M\→.;and go back to the screw dispenser.




	DEFINE	FIND	T D F		\←M\→.;This macro is used to search for the hole
					\←M\→.;The hole is at Trans T offset by a vector D
					\←M\→.;scaled by F
	NNUL				\←M\→.;dont null the first time
	GO T D F NIL 0			\←M\→.;Go to the hole position
	VECT FV				\←M\→.;Maximum resistance that the screw will meet
	0 0 -50
	SEARCH .07			\←M\→.;Set up for a search of 0.7 in steps.
					\←M\→.;Note that the context for the search has been
					\←M\→.;established by the previous GO.
	CONO NIL NIL SCK 10 0 0		\←M\→.;No arrive or depart, move directly
L1:	GO T D F NIL 0			\←M\→.;The search move
	STOP FV NIL			\←M\→.;Try to go down
	NNUL				\←M\→.;without nulling
	CHANGE REACH .6 NIL 0 60	\←M\→.;by 0.6 inches
	SKIPE 23			\←M\→.;if we meet resistance then not in hole
	AOJ L1				\←M\→.;spiral and try again

ERRORS
This is a list of the error messages you might get when running the arm.
When running wave the error message corresponding to the error is typed.

	1	Arithmetic Overflow occured. Something bad has happened.
	<n>1	Excessive force occured at joint <n>
	2	Hand closed more than minimum specified in CLOSE function
	3	File not found
	4	Someone has pawned the DSK
	5	Someone has sold the DSK
	<mask>6	Touch sensors <mask> have touched something
	7	Cannot read the joint positions, usually hardware trouble.
	20	Function took too long to execute
	22	Hand function took too long to execute.
	23	Arm failed to reach force limit set by STOP during motion.
	24	Arm in L1: JUMP L1 type loop.
	25	Save array number out of bound
	27	The function you have called is disconnected.
	30	The arm is down
	50	Librascope read error
	60	You have a very old program which does not match the current servo
	70	The reference supply used by the arm is off.
	100	The PDP6 is not running.
	200	The servo program has been interrupted.


RUNNING THE ARM
\JPower to the arm is controlled by a switch on a box with two lights. The box
is located on the rack under the table near the base of the arm. The yellow
light indicated that the power supply is on and the red light indicated that
the arm is also on.

There is also a grey box on the end of a cable with some switches and a →→→"RED BUTTON"←←←
on it. The buttons are brake releases. The one furthest from the →→→"RED BUTTON"←←←
is joint 1. There is no brake release for joint 6, sorry about that. The last
switch is the hand brake release. All brakes should be turned on when the arm is
being run.

Now for the →→→"RED BUTTON"←←←. If the →→→"RED BUTTON"←←← is pushed while the
arm is running the arm will stop and all brakes will be applied. You should always
be holding the box with your finger over the →→→"RED BUTTON"←←← when running the arm.
For damaging the hand ... -6 acamedic credits. For damaging the arm ... -12 acamedic credits.

There is also a bell that starts 1 second before the arm does 
in the case of a DO and starts with the arm in the case of a P.
The bell goes "ting, ting, ting," just like a truck backing-up, except that
someone stole the bell, oh well!\.

RUNNING THE PROGRAM
The program is on 1,3 and is run by typing
R WAVE
\JThis program will in turn log in a servo program as a PTY job, and will
run a job called [ARM].
When this job is running you will be asked if you want your files saved.
If you respond Y then the arm programs will be written out on the 3330 with
.TRJ extensions. These files may be executed at a later time by simply
 saying DO followed by the file name(with no extension).
If you do not ask to have your files saved fast bands will be used which although
fast will all disappear when you kill your job.

Wave will then announce that it is ready and you can type anything on the previous
pages. 
It will respond with O.K. when it has been supplied all the parameters for the 
function you are defining.
It will then respond with an * when ready for the next function.
Sometimes in execution the servo program will cause trouble.
If it is in the run queue  but not in spacewar mode then someone has the A/D assigned
If it is in the stop queue then you will have to ↑c wave and restart, which will
lose all your macros and data unless you have dumped it.\.